No actionable comments were generated in the recent review. 🎉

Walkthrough

Adds a ResolveDependencies dry-run function to the interpreter that wraps a store in a recordingStore to capture balance and metadata reads during pre-execution, then walks SendStatement AST nodes to conservatively collect potential write targets. Result types and a public method on ParseResult are exposed in numscript.go.

Changes

Dependency Resolution Dry-Run API

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~25 minutes

Suggested reviewers

• Azorlogh

Poem

🐰 Hop hop, the recorder is set,
Each balance and metadata met.
Writes are collected with care,
Conservative paths everywhere.
No posting runs, just a trace—
Dependencies found at a gentle pace! 🌿

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

Codecov Report

❌ Patch coverage is 53.93939% with 76 lines in your changes missing coverage. Please review.
✅ Project coverage is 67.42%. Comparing base (cbc11e8) to head (a1f074b).

@@            Coverage Diff             @@
##             main     #135      +/-   ##
==========================================
- Coverage   67.81%   67.42%   -0.39%     
==========================================
  Files          49       51       +2     
  Lines        5223     5388     +165     
==========================================
+ Hits         3542     3633      +91     
- Misses       1472     1533      +61     
- Partials      209      222      +13     

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

Note on experimental-mid-script-function-call

ResolveDependencies performs Phases 1-2 of RunProgram (variable resolution + balance preloading) but does not execute statements. This means it captures all store reads for standard scripts.

The exception is experimental-mid-script-function-call, which allows calling balance() between send statements:

#![feature("experimental-mid-script-function-call")]

send [USD/2 100] (
  source = @world
  destination = @acc
)

// This balance() reads a value that depends on the first send's result.
// It cannot be discovered without actually executing the statements.
send balance(@acc, USD/2) (
  source = @acc
  destination = @dest
)

In this case, the mid-script balance() call produces a store read that depends on the execution of prior statements. ResolveDependencies cannot capture it because it doesn't execute statements.

To handle this, ResolveDependenciesOptions includes a ForbiddenFlags field. Consumers that need a complete dependency list can forbid this feature:

deps, err := parsed.ResolveDependencies(ctx, vars, store, numscript.ResolveDependenciesOptions{
    ForbiddenFlags: map[string]struct{}{
        "experimental-mid-script-function-call": {},
    },
})

Scripts that declare this feature will be rejected with a ForbiddenFeature error, making the incompleteness explicit rather than silent.

@ascandone updated after the rescope discussion — context for the new approach below.

Rescope

Two concrete needs:

1. Make all store calls deterministic so the host can hash them and detect input drift between successive runs.
2. Return the (account, asset) pairs touched by the script, including those it would write to.

The hashing itself will be done in ledger-v3-poc; on the numscript side we only need to (a) emit store calls in a deterministic order and (b) expose touched accounts.

What changed vs. the previous commit

• No more full execution. Previously ResolveDependencies was running phases 1-2 (vars + balance preload) and RunProgram was an alternative idea — both wasteful. It now performs phases 1-2 (records Reads via a recordingStore wrapper) then statically walks Source / Destination ASTs to collect Writes via evaluateExprAs. No posting is simulated.
• Reads / Writes are separated in the output. Writes are a conservative over-approximation: every account that appears as a source or destination is listed, even if a real run produces no posting for it. The TestResolveDependencies_Nested case now reports {source1, source2, source3, world, dest} instead of just {source1, dest} — which is what the host actually wants for preloading / locking.
• Determinism. Audited the call sites: parseVars iterates []VarDeclaration, the AST traversal iterates []Statement and []Source slices, and runBalancesQuery is called once with a single map. The sequence of GetBalances / GetAccountsMetadata calls is therefore deterministic given identical inputs.
• ForbiddenFlags is gone. It only existed to reject experimental-mid-script-function-call, which was an issue when we did not execute statements. The static walker resolves every account expression via evaluateExprAs, which transparently handles mid-script balance() / meta() in source/destination positions, so the carve-out is no longer needed.

Re-flagging on your earlier point — the test now exercises a case where s2 = meta(@account_that_needs_meta, "k") resolves to source2. Reads.Metadata includes account_that_needs_meta.k and Writes.Volumes includes source2 (statically discovered), so the host has everything it needs to load both into RAM before the hot path runs.